#pragma once

#include <vector>
#include <unordered_set>
#include <unordered_map>
#include <memory>
#include <cstdint>

namespace viml {

// 前向声明
class Bytecode;
class Instruction;

/**
 * 寄存器生命周期区间
 * 表示一个寄存器从定义到最后使用的范围
 */
struct LiveInterval {
    uint32_t register_id;     // 寄存器编号
    size_t start_pc;          // 生命周期起始指令位置
    size_t end_pc;            // 生命周期结束指令位置
    bool is_alive;            // 是否仍在活跃
    
    LiveInterval(uint32_t reg_id, size_t start, size_t end)
        : register_id(reg_id), start_pc(start), end_pc(end), is_alive(true) {}
    
    // 检查两个生命周期是否冲突(有重叠)
    bool conflicts_with(const LiveInterval& other) const {
        return !(end_pc < other.start_pc || other.end_pc < start_pc);
    }
};

/**
 * 活性信息
 * 记录每条指令的活跃寄存器集合
 */
struct LivenessInfo {
    std::unordered_set<uint32_t> live_in;   // 指令入口处的活跃寄存器
    std::unordered_set<uint32_t> live_out;  // 指令出口处的活跃寄存器
    std::unordered_set<uint32_t> def_set;   // 指令定义的寄存器
    std::unordered_set<uint32_t> use_set;   // 指令使用的寄存器
};

/**
 * 寄存器活性分析器
 * 实现基于数据流分析的寄存器生命周期计算
 */
class LivenessAnalyzer {
public:
    LivenessAnalyzer() = default;
    
    /**
     * 分析字节码中的寄存器活性
     * @param bytecode 待分析的字节码
     * @return 是否分析成功
     */
    bool analyze(const std::shared_ptr<Bytecode>& bytecode);
    
    /**
     * 获取指定指令位置的活性信息
     * @param pc 指令位置
     * @return 活性信息引用
     */
    const LivenessInfo& get_liveness_at(size_t pc) const;
    
    /**
     * 获取所有寄存器的生命周期区间
     * @return 生命周期区间列表
     */
    const std::vector<LiveInterval>& get_live_intervals() const {
        return live_intervals_;
    }
    
    /**
     * 获取寄存器冲突图
     * @return 冲突图(邻接表表示)
     */
    const std::unordered_map<uint32_t, std::unordered_set<uint32_t>>& 
    get_conflict_graph() const {
        return conflict_graph_;
    }
    
    /**
     * 重置分析器状态
     */
    void reset();
    
    /**
     * 获取最大活跃寄存器数量
     * @return 峰值寄存器使用数
     */
    size_t get_max_live_registers() const {
        return max_live_registers_;
    }
    
private:
    // 分析阶段
    void compute_def_use_sets(const std::shared_ptr<Bytecode>& bytecode);
    void compute_liveness();
    void build_live_intervals();
    void build_conflict_graph();
    
    // 辅助方法
    void analyze_instruction_def_use(const Instruction& instr, size_t pc);
    std::vector<size_t> get_successors(size_t pc, const Instruction& instr) const;
    
    // 数据成员
    std::vector<LivenessInfo> liveness_info_;           // 每条指令的活性信息
    std::vector<LiveInterval> live_intervals_;          // 寄存器生命周期区间
    std::unordered_map<uint32_t, std::unordered_set<uint32_t>> conflict_graph_;  // 冲突图
    std::vector<Instruction> instructions_;             // 指令副本(用于控制流分析)
    size_t instruction_count_ = 0;                      // 指令总数
    size_t max_live_registers_ = 0;                     // 峰值寄存器数
};

} // namespace viml
